# 🔥 FIX: Configurer le logger avec WebSocket handler pour envoyer les logs au frontend
try:
    from utils.logger import WebSocketLogHandler
    root_logger = logging.getLogger()
    # Vérifier si le handler WebSocket existe déjà
    has_ws_handler = any(isinstance(h, WebSocketLogHandler) for h in root_logger.handlers)
    if not has_ws_handler and ws_manager:
        ws_handler = WebSocketLogHandler()
        ws_handler.set_ws_manager(ws_manager)
        ws_handler.setLevel(logging.INFO)
        # Ne pas formater (garder le message brut avec emojis)
        ws_handler.setFormatter(logging.Formatter('%(message)s'))
        root_logger.addHandler(ws_handler)
        logger.info("✅ WebSocket log handler configuré")

# 🔥 NOUVEAU: Mettre à jour la configuration Telegram
from config import (
    TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID, TELEGRAM_ENABLED,
    TELEGRAM_NOTIFY_POSITION_OPENED, TELEGRAM_NOTIFY_POSITION_CLOSED,
    TELEGRAM_NOTIFY_TP_ESCALIER, TELEGRAM_NOTIFY_EARLY_INVALIDATION,
    TELEGRAM_NOTIFY_ERROR, TELEGRAM_NOTIFY_RECONNECTION,
    TELEGRAM_NOTIFY_DAILY_SUMMARY, TELEGRAM_NOTIFY_RECOVERY_MODE,
    TELEGRAM_NOTIFY_SETUP_REJECTED
)
import os
updated = {}

# Mettre à jour les types de notifications Telegram
notify_types = {
    'TELEGRAM_NOTIFY_POSITION_OPENED': 'TELEGRAM_NOTIFY_POSITION_OPENED',
    'TELEGRAM_NOTIFY_POSITION_CLOSED': 'TELEGRAM_NOTIFY_POSITION_CLOSED',
    'TELEGRAM_NOTIFY_TP_ESCALIER': 'TELEGRAM_NOTIFY_TP_ESCALIER',
    'TELEGRAM_NOTIFY_EARLY_INVALIDATION': 'TELEGRAM_NOTIFY_EARLY_INVALIDATION',
    'TELEGRAM_NOTIFY_ERROR': 'TELEGRAM_NOTIFY_ERROR',
    'TELEGRAM_NOTIFY_RECONNECTION': 'TELEGRAM_NOTIFY_RECONNECTION',
    'TELEGRAM_NOTIFY_DAILY_SUMMARY': 'TELEGRAM_NOTIFY_DAILY_SUMMARY',


 ... (clipped 41 lines)

try:
    from core.websocket_manager import get_websocket_manager
    from datetime import datetime
    import asyncio
    ws_mgr = get_websocket_manager()
    if ws_mgr:
        try:
            loop = asyncio.get_running_loop()
            async def send_log():
                # Format identique à add_log dans main.py
                entry = {
                    'timestamp': datetime.now().strftime('%H:%M:%S'),
                    'level': 'INFO',  # 🔥 FIX: INFO au lieu de WARNING
                    'message': f"ℹ️ Setup {best_setup['direction']} rejeté",
                    'detail': f"{symbol}: Orderbook défavorable (ratio={orderbook_check['ratio']:.2f}, required={required_str})",
                    'raw_message': f"Setup {best_setup['direction']} rejeté"
                }
                await ws_mgr.emit('log', entry)
            loop.create_task(send_log())
        except RuntimeError:
            # Pas de loop en cours, ignorer (le log est déjà dans logger.info)


 ... (clipped 3 lines)

Returns:
    Slippage estimé en %
"""
# 🔥 INFO: Log pour vérifier les paramètres (changer de debug à info pour visibilité)
logger.info(f"💹 _estimate_slippage: order_size={order_size}, spread_pct={spread_pct}, depth={depth}, balance_score={balance_score}")

if spread_pct <= 0 or depth <= 0:
    logger.warning(f"💹 _estimate_slippage: Retourne 0.0 car spread_pct={spread_pct} ou depth={depth} <= 0")
    return 0.0

    else:
        raise ValueError('Aucune position active')

elif command == 'update_telegram_config':
    # 🔥 NOUVEAU: Mettre à jour la configuration Telegram
    from config import (
        TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID, TELEGRAM_ENABLED,
        TELEGRAM_NOTIFY_POSITION_OPENED, TELEGRAM_NOTIFY_POSITION_CLOSED,
        TELEGRAM_NOTIFY_TP_ESCALIER, TELEGRAM_NOTIFY_EARLY_INVALIDATION,
        TELEGRAM_NOTIFY_ERROR, TELEGRAM_NOTIFY_RECONNECTION,
        TELEGRAM_NOTIFY_DAILY_SUMMARY, TELEGRAM_NOTIFY_RECOVERY_MODE,
        TELEGRAM_NOTIFY_SETUP_REJECTED
    )
    import os
    updated = {}

    # Mettre à jour les types de notifications Telegram
    notify_types = {
        'TELEGRAM_NOTIFY_POSITION_OPENED': 'TELEGRAM_NOTIFY_POSITION_OPENED',
        'TELEGRAM_NOTIFY_POSITION_CLOSED': 'TELEGRAM_NOTIFY_POSITION_CLOSED',
        'TELEGRAM_NOTIFY_TP_ESCALIER': 'TELEGRAM_NOTIFY_TP_ESCALIER',


 ... (clipped 65 lines)

# Récupérer orderbook
orderbook = await client.fetch_order_book(symbol, limit=5)

# 🔥 FIX: Vérifier que orderbook n'est pas None et contient bids/asks
if orderbook is None:
    # 🔥 FIX: Ne pas logger ici car WebSocketLogHandler capture déjà logger.error et envoie au frontend
    # Le log sera envoyé automatiquement via WebSocketLogHandler
    return {'valid': False, 'spread_pct': 999, 'max_allowed': 0.03, 'quality': 'ERROR'}

bids = orderbook.get('bids', []) if orderbook else []
asks = orderbook.get('asks', []) if orderbook else []

best_bid = bids[0][0] if bids and len(bids) > 0 and len(bids[0]) > 0 else 0
best_ask = asks[0][0] if asks and len(asks) > 0 and len(asks[0]) > 0 else 0

if best_bid == 0 or best_ask == 0:
    return {'valid': False, 'spread_pct': 999, 'max_allowed': 0.03, 'quality': 'UNKNOWN'}

mid_price = (best_bid + best_ask) / 2
spread_pct = ((best_ask - best_bid) / mid_price) * 100



 ... (clipped 41 lines)

# 🔥 FIX: Configurer le logger avec WebSocket handler pour envoyer les logs au frontend
try:
    from utils.logger import WebSocketLogHandler
    root_logger = logging.getLogger()
    # Vérifier si le handler WebSocket existe déjà
    has_ws_handler = any(isinstance(h, WebSocketLogHandler) for h in root_logger.handlers)
    if not has_ws_handler and ws_manager:
        ws_handler = WebSocketLogHandler()
        ws_handler.set_ws_manager(ws_manager)
        ws_handler.setLevel(logging.INFO)
        # Ne pas formater (garder le message brut avec emojis)
        ws_handler.setFormatter(logging.Formatter('%(message)s'))
        root_logger.addHandler(ws_handler)
        logger.info("✅ WebSocket log handler configuré")
except Exception as e:
    logger.debug(f"Impossible de configurer WebSocket log handler: {e}")

)

# Calculer slippage si applicable
# 🔥 FIX: _estimate_slippage retourne un pourcentage (%)
slippage_pct = 0.0
# 🔥 INFO: Log pour vérifier les conditions (changer de debug à info pour visibilité)
logger.info(f"💹 Calcul slippage: use_slippage_calculation={self.config.use_slippage_calculation}, "
           f"scalability_data={'présent' if self.active_position.scalability_data else 'absent'}")

if self.config.use_slippage_calculation and self.active_position.scalability_data:
    spread_pct = self.active_position.scalability_data.get('spread_pct', 0.0)
    depth = self.active_position.scalability_data.get('depth', 0.0)
    balance = self.active_position.scalability_data.get('balance', 1.0)

    logger.info(f"💹 Données scalabilité: spread_pct={spread_pct}, depth={depth}, balance={balance}, size={self.active_position.size}")

    slippage_pct = self._estimate_slippage(
        order_size=self.active_position.size,
        spread_pct=spread_pct,
        depth=depth,
        balance_score=balance,


 ... (clipped 125 lines)

elif command == 'update_telegram_config':
    # 🔥 NOUVEAU: Mettre à jour la configuration Telegram
    from config import (
        TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID, TELEGRAM_ENABLED,
        TELEGRAM_NOTIFY_POSITION_OPENED, TELEGRAM_NOTIFY_POSITION_CLOSED,
        TELEGRAM_NOTIFY_TP_ESCALIER, TELEGRAM_NOTIFY_EARLY_INVALIDATION,
        TELEGRAM_NOTIFY_ERROR, TELEGRAM_NOTIFY_RECONNECTION,
        TELEGRAM_NOTIFY_DAILY_SUMMARY, TELEGRAM_NOTIFY_RECOVERY_MODE,
        TELEGRAM_NOTIFY_SETUP_REJECTED
    )
    import os
    updated = {}

    # Mettre à jour les types de notifications Telegram
    notify_types = {
        'TELEGRAM_NOTIFY_POSITION_OPENED': 'TELEGRAM_NOTIFY_POSITION_OPENED',
        'TELEGRAM_NOTIFY_POSITION_CLOSED': 'TELEGRAM_NOTIFY_POSITION_CLOSED',
        'TELEGRAM_NOTIFY_TP_ESCALIER': 'TELEGRAM_NOTIFY_TP_ESCALIER',
        'TELEGRAM_NOTIFY_EARLY_INVALIDATION': 'TELEGRAM_NOTIFY_EARLY_INVALIDATION',
        'TELEGRAM_NOTIFY_ERROR': 'TELEGRAM_NOTIFY_ERROR',
        'TELEGRAM_NOTIFY_RECONNECTION': 'TELEGRAM_NOTIFY_RECONNECTION',


 ... (clipped 42 lines)

# 🔥 FIX: Configurer le logger avec WebSocket handler pour envoyer les logs au frontend
try:
    from utils.logger import WebSocketLogHandler
    root_logger = logging.getLogger()
    # Vérifier si le handler WebSocket existe déjà
    has_ws_handler = any(isinstance(h, WebSocketLogHandler) for h in root_logger.handlers)
    if not has_ws_handler and ws_manager:
        ws_handler = WebSocketLogHandler()
        ws_handler.set_ws_manager(ws_manager)
        ws_handler.setLevel(logging.INFO)
        # Ne pas formater (garder le message brut avec emojis)
        ws_handler.setFormatter(logging.Formatter('%(message)s'))
        root_logger.addHandler(ws_handler)
        logger.info("✅ WebSocket log handler configuré")

)

# Calculer slippage si applicable
# 🔥 FIX: _estimate_slippage retourne un pourcentage (%)
slippage_pct = 0.0
# 🔥 INFO: Log pour vérifier les conditions (changer de debug à info pour visibilité)
logger.info(f"💹 Calcul slippage: use_slippage_calculation={self.config.use_slippage_calculation}, "
           f"scalability_data={'présent' if self.active_position.scalability_data else 'absent'}")

if self.config.use_slippage_calculation and self.active_position.scalability_data:
    spread_pct = self.active_position.scalability_data.get('spread_pct', 0.0)
    depth = self.active_position.scalability_data.get('depth', 0.0)
    balance = self.active_position.scalability_data.get('balance', 1.0)

    logger.info(f"💹 Données scalabilité: spread_pct={spread_pct}, depth={depth}, balance={balance}, size={self.active_position.size}")

    slippage_pct = self._estimate_slippage(
        order_size=self.active_position.size,
        spread_pct=spread_pct,
        depth=depth,
        balance_score=balance,


 ... (clipped 26 lines)

# 🔥 TP/SL Mode
if 'tp_sl_mode' in params:
    mode = str(params['tp_sl_mode']).upper()
    # 🔥 FIX: Accepter aussi 'ESCALIER' comme mode valide
    if mode in ['FIXE', 'ATR', 'TP_MULTI', 'ESCALIER']:
        TRADING_CONFIG['tp_sl_mode'] = mode
        # 🔥 FIX: Ne pas appeler init_instances() car cela réinitialise tout, utiliser directement position_config et position_manager
        if position_config:
            position_config.use_atr = (mode == 'ATR' or mode == 'TP_MULTI' or mode == 'ESCALIER')
        # 🔥 FIX: Mettre à jour aussi position_manager.config.use_atr si position_manager existe
        if position_manager:
            position_manager.config.use_atr = (mode == 'ATR' or mode == 'TP_MULTI' or mode == 'ESCALIER')
        updated['tp_sl_mode'] = mode
        logger.info(f"✅ Mode TP/SL mis à jour: {mode} (use_atr={position_config.use_atr if position_config else 'N/A'})")

if 'tp_percent' in params:
    val = float(params['tp_percent'])
    TRADING_CONFIG['tp_percent'] = val
    if position_config:
        position_config.fixed_tp_pct = val
    updated['tp_percent'] = val


 ... (clipped 486 lines)

# Calculer PnL pour affichage
position = position_manager.active_position
if position:
    # 🔥 FIX: Vérifier que position est un objet Position et non un dict ou string
    if isinstance(position, str):
        # Si position est une chaîne, essayer de la parser en dict
        import json
        try:
            position_dict = json.loads(position)
            # Utiliser les valeurs du dict pour calculer PnL
            pnl = position_manager.pnl_calculator.calculate_pnl_percent(
                entry=position_dict.get('entry', 0),
                current_price=current_price,
                direction=position_dict.get('direction', 'LONG')
            )
            pnl_usdt = position_manager.pnl_calculator.calculate_pnl_usdt(
                position=position_dict,
                current_price=current_price
            )
            # Créer un objet position-like pour le reste du code
            class PositionProxy:


 ... (clipped 50 lines)

    return result

except Exception as e:
    error_msg = f"❌ Erreur check spread {symbol}: {e}"
    # 🔥 FIX: logger.error est capturé par WebSocketLogHandler et envoyé au frontend automatiquement
    # Pas besoin d'envoyer manuellement via websocket_manager.emit (cela créerait un doublon)
    logger.error(error_msg)
    return {'valid': False, 'spread_pct': 999, 'max_allowed': 0.03, 'quality': 'ERROR'}

    else:
        raise ValueError('Aucune position active')

elif command == 'update_telegram_config':
    # 🔥 NOUVEAU: Mettre à jour la configuration Telegram
    from config import (
        TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID, TELEGRAM_ENABLED,
        TELEGRAM_NOTIFY_POSITION_OPENED, TELEGRAM_NOTIFY_POSITION_CLOSED,
        TELEGRAM_NOTIFY_TP_ESCALIER, TELEGRAM_NOTIFY_EARLY_INVALIDATION,
        TELEGRAM_NOTIFY_ERROR, TELEGRAM_NOTIFY_RECONNECTION,
        TELEGRAM_NOTIFY_DAILY_SUMMARY, TELEGRAM_NOTIFY_RECOVERY_MODE,
        TELEGRAM_NOTIFY_SETUP_REJECTED
    )
    import os
    updated = {}

    # Mettre à jour les types de notifications Telegram
    notify_types = {
        'TELEGRAM_NOTIFY_POSITION_OPENED': 'TELEGRAM_NOTIFY_POSITION_OPENED',
        'TELEGRAM_NOTIFY_POSITION_CLOSED': 'TELEGRAM_NOTIFY_POSITION_CLOSED',
        'TELEGRAM_NOTIFY_TP_ESCALIER': 'TELEGRAM_NOTIFY_TP_ESCALIER',


 ... (clipped 45 lines)

# 🔥 TP/SL Mode
if 'tp_sl_mode' in params:
    mode = str(params['tp_sl_mode']).upper()
    # 🔥 FIX: Accepter aussi 'ESCALIER' comme mode valide
    if mode in ['FIXE', 'ATR', 'TP_MULTI', 'ESCALIER']:
        TRADING_CONFIG['tp_sl_mode'] = mode
        # 🔥 FIX: Ne pas appeler init_instances() car cela réinitialise tout, utiliser directement position_config et position_manager
        if position_config:
            position_config.use_atr = (mode == 'ATR' or mode == 'TP_MULTI' or mode == 'ESCALIER')
        # 🔥 FIX: Mettre à jour aussi position_manager.config.use_atr si position_manager existe
        if position_manager:
            position_manager.config.use_atr = (mode == 'ATR' or mode == 'TP_MULTI' or mode == 'ESCALIER')
        updated['tp_sl_mode'] = mode
        logger.info(f"✅ Mode TP/SL mis à jour: {mode} (use_atr={position_config.use_atr if position_config else 'N/A'})")

if 'tp_percent' in params:
    val = float(params['tp_percent'])
    TRADING_CONFIG['tp_percent'] = val
    if position_config:
        position_config.fixed_tp_pct = val
    updated['tp_percent'] = val


 ... (clipped 486 lines)

                # 🔥 FIX: Vérifier que position est un objet Position et non un dict ou string
                if isinstance(position, str):
                    # Si position est une chaîne, essayer de la parser en dict
                    import json
                    try:
                        position_dict = json.loads(position)
                        # Utiliser les valeurs du dict pour calculer PnL
                        pnl = position_manager.pnl_calculator.calculate_pnl_percent(
                            entry=position_dict.get('entry', 0),
                            current_price=current_price,

 ... (clipped 57 lines)